/*
** Lua binding: gamebryo
** Generated automatically by tolua++-1.0.92 on 03/27/16 21:10:51.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
int tolua_gamebryo_open (lua_State* tolua_S);

#include "Engine.h"
#define new EE_NEW
 template<typename T> void _EE_DELETE(T* pObject) { delete pObject; }
inline NiDX9Renderer* NiDX9Renderer_Create(int wnd, int flags) { return NiDX9Renderer::Create(0, 0, flags, (HWND)wnd, NULL); }
	static void _NiDrawScene_(NiCamera* pkCamera, NiAVObject* pkScene) 
	{ 
		NiVisibleArray kVisible(32, 32);	
		NiMeshCullingProcess kCuller(&kVisible, NULL); 
		NiDrawScene(pkCamera, pkScene,  kCuller, NULL); 
	}

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_NiFrustum (lua_State* tolua_S)
{
 NiFrustum* self = (NiFrustum*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiColor (lua_State* tolua_S)
{
 NiColor* self = (NiColor*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiNode (lua_State* tolua_S)
{
 NiNode* self = (NiNode*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_sp_NiNode_ (lua_State* tolua_S)
{
 sp<NiNode>* self = (sp<NiNode>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_ptr_NiFrustum_ (lua_State* tolua_S)
{
 ptr<NiFrustum>* self = (ptr<NiFrustum>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_ptr_NiPNGReader_ (lua_State* tolua_S)
{
 ptr<NiPNGReader>* self = (ptr<NiPNGReader>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiStream (lua_State* tolua_S)
{
 NiStream* self = (NiStream*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiAmbientLight (lua_State* tolua_S)
{
 NiAmbientLight* self = (NiAmbientLight*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_ptr_NiDDSReader_ (lua_State* tolua_S)
{
 ptr<NiDDSReader>* self = (ptr<NiDDSReader>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiDevImageConverter (lua_State* tolua_S)
{
 NiDevImageConverter* self = (NiDevImageConverter*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_ptr_NiColor_ (lua_State* tolua_S)
{
 ptr<NiColor>* self = (ptr<NiColor>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiCamera (lua_State* tolua_S)
{
 NiCamera* self = (NiCamera*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiFogProperty (lua_State* tolua_S)
{
 NiFogProperty* self = (NiFogProperty*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_sp_NiAlphaAccumulator_ (lua_State* tolua_S)
{
 sp<NiAlphaAccumulator>* self = (sp<NiAlphaAccumulator>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiPNGReader (lua_State* tolua_S)
{
 NiPNGReader* self = (NiPNGReader*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_sp_NiDX9Renderer_ (lua_State* tolua_S)
{
 sp<NiDX9Renderer>* self = (sp<NiDX9Renderer>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_ptr_NiTGAReader_ (lua_State* tolua_S)
{
 ptr<NiTGAReader>* self = (ptr<NiTGAReader>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_NiPoint3 (lua_State* tolua_S)
{
 NiPoint3* self = (NiPoint3*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_sp_NiCamera_ (lua_State* tolua_S)
{
 sp<NiCamera>* self = (sp<NiCamera>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_sp_NiDevImageConverter_ (lua_State* tolua_S)
{
 sp<NiDevImageConverter>* self = (sp<NiDevImageConverter>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_sp_NiObject_ (lua_State* tolua_S)
{
 sp<NiObject>* self = (sp<NiObject>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_ptr_NiPoint3_ (lua_State* tolua_S)
{
 ptr<NiPoint3>* self = (ptr<NiPoint3>*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"NiColor");
 tolua_usertype(tolua_S,"NiRTTI");
 tolua_usertype(tolua_S,"NiObjectNET");
 tolua_usertype(tolua_S,"NiNode");
 tolua_usertype(tolua_S,"ptr<NiFrustum>");
 tolua_usertype(tolua_S,"NiTGAReader");
 tolua_usertype(tolua_S,"ptr<NiPNGReader>");
 tolua_usertype(tolua_S,"NiStream");
 tolua_usertype(tolua_S,"ptr<NiPoint3>");
 tolua_usertype(tolua_S,"NiLight");
 tolua_usertype(tolua_S,"ptr<NiDDSReader>");
 tolua_usertype(tolua_S,"NiCamera");
 tolua_usertype(tolua_S,"NiAccumulator");
 tolua_usertype(tolua_S,"NiActorManager");
 tolua_usertype(tolua_S,"sp<NiDX9Renderer>");
 tolua_usertype(tolua_S,"ptr<NiTGAReader>");
 tolua_usertype(tolua_S,"NiSourceTexture");
 tolua_usertype(tolua_S,"NiRefObject");
 tolua_usertype(tolua_S,"efd::Point3");
 tolua_usertype(tolua_S,"NiFrustum");
 tolua_usertype(tolua_S,"NiTexture");
 tolua_usertype(tolua_S,"NiProperty");
 tolua_usertype(tolua_S,"NiDX9Renderer");
 tolua_usertype(tolua_S,"IDirect3DDevice9");
 tolua_usertype(tolua_S,"NiMaterial");
 tolua_usertype(tolua_S,"sp<NiNode>");
 tolua_usertype(tolua_S,"NiAVObject");
 tolua_usertype(tolua_S,"sp<NiAlphaAccumulator>");
 tolua_usertype(tolua_S,"NiAlphaAccumulator");
 tolua_usertype(tolua_S,"NiBackToFrontAccumulator");
 tolua_usertype(tolua_S,"NiDevImageConverter");
 tolua_usertype(tolua_S,"NiImageConverter");
 tolua_usertype(tolua_S,"NiDynamicEffectList");
 tolua_usertype(tolua_S,"NiDDSReader");
 tolua_usertype(tolua_S,"NiRenderer");
 tolua_usertype(tolua_S,"NiImageReader");
 tolua_usertype(tolua_S,"NiPoint3");
 tolua_usertype(tolua_S,"sp<NiObject>");
 tolua_usertype(tolua_S,"NiDynamicEffect");
 tolua_usertype(tolua_S,"NiObject");
 tolua_usertype(tolua_S,"NiPNGReader");
 tolua_usertype(tolua_S,"ptr<NiColor>");
 tolua_usertype(tolua_S,"NiFogProperty");
 tolua_usertype(tolua_S,"NiAmbientLight");
 tolua_usertype(tolua_S,"sp<NiCamera>");
 tolua_usertype(tolua_S,"sp<NiDevImageConverter>");
 tolua_usertype(tolua_S,"NiTerrain");
 tolua_usertype(tolua_S,"efd::MemObject");
}

/* get function: x of class  efd::Point3 */
#ifndef TOLUA_DISABLE_tolua_get_efd__Point3_x
static int tolua_get_efd__Point3_x(lua_State* tolua_S)
{
  efd::Point3* self = (efd::Point3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: x of class  efd::Point3 */
#ifndef TOLUA_DISABLE_tolua_set_efd__Point3_x
static int tolua_set_efd__Point3_x(lua_State* tolua_S)
{
  efd::Point3* self = (efd::Point3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->x = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: y of class  efd::Point3 */
#ifndef TOLUA_DISABLE_tolua_get_efd__Point3_y
static int tolua_get_efd__Point3_y(lua_State* tolua_S)
{
  efd::Point3* self = (efd::Point3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: y of class  efd::Point3 */
#ifndef TOLUA_DISABLE_tolua_set_efd__Point3_y
static int tolua_set_efd__Point3_y(lua_State* tolua_S)
{
  efd::Point3* self = (efd::Point3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->y = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: z of class  efd::Point3 */
#ifndef TOLUA_DISABLE_tolua_get_efd__Point3_z
static int tolua_get_efd__Point3_z(lua_State* tolua_S)
{
  efd::Point3* self = (efd::Point3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->z);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: z of class  efd::Point3 */
#ifndef TOLUA_DISABLE_tolua_set_efd__Point3_z
static int tolua_set_efd__Point3_z(lua_State* tolua_S)
{
  efd::Point3* self = (efd::Point3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->z = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiColor_new00
static int tolua_gamebryo_NiColor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiColor* tolua_ret = (NiColor*)  new NiColor();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiColor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiColor_new00_local
static int tolua_gamebryo_NiColor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiColor* tolua_ret = (NiColor*)  new NiColor();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiColor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiColor_new01
static int tolua_gamebryo_NiColor_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiColor",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
  float g = ((float)  tolua_tonumber(tolua_S,3,0));
  float b = ((float)  tolua_tonumber(tolua_S,4,0));
 {
  NiColor* tolua_ret = (NiColor*)  new NiColor(r,g,b);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiColor");
 }
 }
 return 1;
tolua_lerror:
 return tolua_gamebryo_NiColor_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiColor_new01_local
static int tolua_gamebryo_NiColor_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiColor",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
  float g = ((float)  tolua_tonumber(tolua_S,3,0));
  float b = ((float)  tolua_tonumber(tolua_S,4,0));
 {
  NiColor* tolua_ret = (NiColor*)  new NiColor(r,g,b);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiColor");
 }
 }
 return 1;
tolua_lerror:
 return tolua_gamebryo_NiColor_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiColor_delete00
static int tolua_gamebryo_NiColor_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiColor* self = (NiColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: r of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_get_NiColor_r
static int tolua_get_NiColor_r(lua_State* tolua_S)
{
  NiColor* self = (NiColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'r'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->r);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: r of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_set_NiColor_r
static int tolua_set_NiColor_r(lua_State* tolua_S)
{
  NiColor* self = (NiColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'r'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->r = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: g of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_get_NiColor_g
static int tolua_get_NiColor_g(lua_State* tolua_S)
{
  NiColor* self = (NiColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'g'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->g);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: g of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_set_NiColor_g
static int tolua_set_NiColor_g(lua_State* tolua_S)
{
  NiColor* self = (NiColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'g'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->g = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: b of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_get_NiColor_b
static int tolua_get_NiColor_b(lua_State* tolua_S)
{
  NiColor* self = (NiColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: b of class  NiColor */
#ifndef TOLUA_DISABLE_tolua_set_NiColor_b
static int tolua_set_NiColor_b(lua_State* tolua_S)
{
  NiColor* self = (NiColor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->b = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiPoint3 */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiPoint3_new00
static int tolua_gamebryo_NiPoint3_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiPoint3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiPoint3* tolua_ret = (NiPoint3*)  new NiPoint3();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiPoint3");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiPoint3 */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiPoint3_new00_local
static int tolua_gamebryo_NiPoint3_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiPoint3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiPoint3* tolua_ret = (NiPoint3*)  new NiPoint3();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiPoint3");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiPoint3 */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiPoint3_new01
static int tolua_gamebryo_NiPoint3_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiPoint3",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
  float z = ((float)  tolua_tonumber(tolua_S,4,0));
 {
  NiPoint3* tolua_ret = (NiPoint3*)  new NiPoint3(x,y,z);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiPoint3");
 }
 }
 return 1;
tolua_lerror:
 return tolua_gamebryo_NiPoint3_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiPoint3 */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiPoint3_new01_local
static int tolua_gamebryo_NiPoint3_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiPoint3",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
  float z = ((float)  tolua_tonumber(tolua_S,4,0));
 {
  NiPoint3* tolua_ret = (NiPoint3*)  new NiPoint3(x,y,z);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiPoint3");
 }
 }
 return 1;
tolua_lerror:
 return tolua_gamebryo_NiPoint3_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  NiPoint3 */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiPoint3_delete00
static int tolua_gamebryo_NiPoint3_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiPoint3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiPoint3* self = (NiPoint3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IncRefCount of class  NiRefObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRefObject_IncRefCount00
static int tolua_gamebryo_NiRefObject_IncRefCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRefObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRefObject* self = (NiRefObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IncRefCount'",NULL);
#endif
 {
  self->IncRefCount();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IncRefCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DecRefCount of class  NiRefObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRefObject_DecRefCount00
static int tolua_gamebryo_NiRefObject_DecRefCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRefObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRefObject* self = (NiRefObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DecRefCount'",NULL);
#endif
 {
  self->DecRefCount();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DecRefCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRefCount of class  NiRefObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRefObject_GetRefCount00
static int tolua_gamebryo_NiRefObject_GetRefCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiRefObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiRefObject* self = (const NiRefObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRefCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->GetRefCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRefCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTotalObjectCount of class  NiRefObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRefObject_GetTotalObjectCount00
static int tolua_gamebryo_NiRefObject_GetTotalObjectCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiRefObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  unsigned int tolua_ret = (unsigned int)  NiRefObject::GetTotalObjectCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTotalObjectCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  NiRTTI */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRTTI_GetName00
static int tolua_gamebryo_NiRTTI_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRTTI",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRTTI* self = (NiRTTI*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'",NULL);
#endif
 {
  char* tolua_ret = (char*)  self->GetName();
 tolua_pushstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRTTI of class  NiObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiObject_GetRTTI00
static int tolua_gamebryo_NiObject_GetRTTI00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiObject* self = (NiObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRTTI'",NULL);
#endif
 {
  NiRTTI* tolua_ret = (NiRTTI*)  self->GetRTTI();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiRTTI");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRTTI'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  sp<NiObject> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiObject__new00
static int tolua_gamebryo_sp_NiObject__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiObject>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiObject>* tolua_ret = (sp<NiObject>*)  new sp<NiObject>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"sp<NiObject>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  sp<NiObject> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiObject__new00_local
static int tolua_gamebryo_sp_NiObject__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiObject>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiObject>* tolua_ret = (sp<NiObject>*)  new sp<NiObject>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"sp<NiObject>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  sp<NiObject> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiObject__delete00
static int tolua_gamebryo_sp_NiObject__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiObject>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiObject>* self = (sp<NiObject>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  sp<NiObject> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiObject__put00
static int tolua_gamebryo_sp_NiObject__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiObject>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiObject>* self = (sp<NiObject>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  sp<NiObject> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiObject__get00
static int tolua_gamebryo_sp_NiObject__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiObject>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiObject>* self = (sp<NiObject>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiObject* tolua_ret = (NiObject*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiObject");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  sp<NiObject> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiObject__set00
static int tolua_gamebryo_sp_NiObject__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiObject>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiObject>* self = (sp<NiObject>*)  tolua_tousertype(tolua_S,1,0);
  NiObject* tolua_var_1 = ((NiObject*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_1);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiObjectNET_GetName of class  NiObjectNET */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiObjectNET_GetName00
static int tolua_gamebryo_NiObjectNET_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiObjectNET",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiObjectNET* self = (NiObjectNET*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiObjectNET_GetName'",NULL);
#endif
 {
  string tolua_ret = (string)  NiObjectNET_GetName(self);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiObjectNET_SetName of class  NiObjectNET */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiObjectNET_SetName00
static int tolua_gamebryo_NiObjectNET_SetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiObjectNET",0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiObjectNET* self = (NiObjectNET*)  tolua_tousertype(tolua_S,1,0);
  string tolua_var_2 = ((string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiObjectNET_SetName'",NULL);
#endif
 {
  NiObjectNET_SetName(self,tolua_var_2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Type of class  NiProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiProperty_Type00
static int tolua_gamebryo_NiProperty_Type00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiProperty* self = (const NiProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Type'",NULL);
#endif
 {
  int tolua_ret = (int)  self->Type();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Type'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Update of class  NiProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiProperty_Update00
static int tolua_gamebryo_NiProperty_Update00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiProperty",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiProperty* self = (NiProperty*)  tolua_tousertype(tolua_S,1,0);
  float fTime = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Update'",NULL);
#endif
 {
  self->Update(fTime);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Update'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetAppCulled of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_SetAppCulled00
static int tolua_gamebryo_NiAVObject_SetAppCulled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  bool bAppCulled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAppCulled'",NULL);
#endif
 {
  self->SetAppCulled(bAppCulled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetAppCulled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAppCulled of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_GetAppCulled00
static int tolua_gamebryo_NiAVObject_GetAppCulled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAppCulled'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->GetAppCulled();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAppCulled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiAVObject_GetObjectByName of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_GetObjectByName00
static int tolua_gamebryo_NiAVObject_GetObjectByName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  string tolua_var_3 = ((string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiAVObject_GetObjectByName'",NULL);
#endif
 {
  NiAVObject* tolua_ret = (NiAVObject*)  NiAVObject_GetObjectByName(self,tolua_var_3);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiAVObject");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetObjectByName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetTranslate of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_SetTranslate00
static int tolua_gamebryo_NiAVObject_SetTranslate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiPoint3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  const NiPoint3* kTrn = ((const NiPoint3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTranslate'",NULL);
#endif
 {
  self->SetTranslate(*kTrn);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetTranslate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetTranslate of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_SetTranslate01
static int tolua_gamebryo_NiAVObject_SetTranslate01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
  float z = ((float)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTranslate'",NULL);
#endif
 {
  self->SetTranslate(x,y,z);
 }
 }
 return 0;
tolua_lerror:
 return tolua_gamebryo_NiAVObject_SetTranslate00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetScale of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_SetScale00
static int tolua_gamebryo_NiAVObject_SetScale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  float fScale = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetScale'",NULL);
#endif
 {
  self->SetScale(fScale);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetScale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRotate of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_SetRotate00
static int tolua_gamebryo_NiAVObject_SetRotate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  float fAngle = ((float)  tolua_tonumber(tolua_S,2,0));
  float x = ((float)  tolua_tonumber(tolua_S,3,0));
  float y = ((float)  tolua_tonumber(tolua_S,4,0));
  float z = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRotate'",NULL);
#endif
 {
  self->SetRotate(fAngle,x,y,z);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRotate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Update of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_Update00
static int tolua_gamebryo_NiAVObject_Update00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  float fTime = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Update'",NULL);
#endif
 {
  self->Update(fTime);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Update'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiAVObject_UpdateAll of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_UpdateAll00
static int tolua_gamebryo_NiAVObject_UpdateAll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  float fTime = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiAVObject_UpdateAll'",NULL);
#endif
 {
  NiAVObject_UpdateAll(self,fTime);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UpdateAll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UpdateProperties of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_UpdateProperties00
static int tolua_gamebryo_NiAVObject_UpdateProperties00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UpdateProperties'",NULL);
#endif
 {
  self->UpdateProperties();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UpdateProperties'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AttachProperty of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_AttachProperty00
static int tolua_gamebryo_NiAVObject_AttachProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  NiProperty* pkProperty = ((NiProperty*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AttachProperty'",NULL);
#endif
 {
  self->AttachProperty(pkProperty);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AttachProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DetachProperty of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_DetachProperty00
static int tolua_gamebryo_NiAVObject_DetachProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
  NiProperty* pkProperty = ((NiProperty*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DetachProperty'",NULL);
#endif
 {
  self->DetachProperty(pkProperty);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DetachProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiAVObject_ToNiNode of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_ToNiNode00
static int tolua_gamebryo_NiAVObject_ToNiNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiAVObject_ToNiNode'",NULL);
#endif
 {
  NiNode* tolua_ret = (NiNode*)  NiAVObject_ToNiNode(self);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiNode");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ToNiNode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiAVObject_ToNiTerrain of class  NiAVObject */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAVObject_ToNiTerrain00
static int tolua_gamebryo_NiAVObject_ToNiTerrain00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAVObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAVObject* self = (NiAVObject*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiAVObject_ToNiTerrain'",NULL);
#endif
 {
  NiTerrain* tolua_ret = (NiTerrain*)  NiAVObject_ToNiTerrain(self);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiTerrain");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ToNiTerrain'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_new00
static int tolua_gamebryo_NiNode_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiNode* tolua_ret = (NiNode*)  new NiNode();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiNode");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_new00_local
static int tolua_gamebryo_NiNode_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiNode* tolua_ret = (NiNode*)  new NiNode();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiNode");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CompactChildArray of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_CompactChildArray00
static int tolua_gamebryo_NiNode_CompactChildArray00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CompactChildArray'",NULL);
#endif
 {
  self->CompactChildArray();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CompactChildArray'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAt of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_GetAt00
static int tolua_gamebryo_NiNode_GetAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
  unsigned int i = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAt'",NULL);
#endif
 {
  NiAVObject* tolua_ret = (NiAVObject*)  self->GetAt(i);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiAVObject");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetChildCount of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_GetChildCount00
static int tolua_gamebryo_NiNode_GetChildCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChildCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->GetChildCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetChildCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetArrayCount of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_GetArrayCount00
static int tolua_gamebryo_NiNode_GetArrayCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiNode* self = (const NiNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetArrayCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->GetArrayCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetArrayCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AttachChild of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_AttachChild00
static int tolua_gamebryo_NiNode_AttachChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiAVObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
  NiAVObject* pkChild = ((NiAVObject*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AttachChild'",NULL);
#endif
 {
  self->AttachChild(pkChild);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AttachChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DetachChild of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_DetachChild00
static int tolua_gamebryo_NiNode_DetachChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiAVObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
  NiAVObject* pkChild = ((NiAVObject*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DetachChild'",NULL);
#endif
 {
  NiAVObject* tolua_ret = (NiAVObject*)  self->DetachChild(pkChild);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiAVObject");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DetachChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEffectList of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_GetEffectList00
static int tolua_gamebryo_NiNode_GetEffectList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiNode* self = (const NiNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEffectList'",NULL);
#endif
 {
  const NiDynamicEffectList& tolua_ret = (const NiDynamicEffectList&)  self->GetEffectList();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const NiDynamicEffectList");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEffectList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AttachEffect of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_AttachEffect00
static int tolua_gamebryo_NiNode_AttachEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiDynamicEffect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
  NiDynamicEffect* pkEffect = ((NiDynamicEffect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AttachEffect'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->AttachEffect(pkEffect);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AttachEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DetachEffect of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_DetachEffect00
static int tolua_gamebryo_NiNode_DetachEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiDynamicEffect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
  NiDynamicEffect* pkEffect = ((NiDynamicEffect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DetachEffect'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->DetachEffect(pkEffect);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DetachEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DetachAllEffects of class  NiNode */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiNode_DetachAllEffects00
static int tolua_gamebryo_NiNode_DetachAllEffects00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiNode* self = (NiNode*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DetachAllEffects'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->DetachAllEffects();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DetachAllEffects'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  sp<NiNode> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiNode__new00
static int tolua_gamebryo_sp_NiNode__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiNode>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiNode>* tolua_ret = (sp<NiNode>*)  new sp<NiNode>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"sp<NiNode>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  sp<NiNode> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiNode__new00_local
static int tolua_gamebryo_sp_NiNode__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiNode>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiNode>* tolua_ret = (sp<NiNode>*)  new sp<NiNode>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"sp<NiNode>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  sp<NiNode> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiNode__delete00
static int tolua_gamebryo_sp_NiNode__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiNode>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiNode>* self = (sp<NiNode>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  sp<NiNode> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiNode__put00
static int tolua_gamebryo_sp_NiNode__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiNode>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiNode>* self = (sp<NiNode>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  sp<NiNode> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiNode__get00
static int tolua_gamebryo_sp_NiNode__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiNode>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiNode>* self = (sp<NiNode>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiNode* tolua_ret = (NiNode*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiNode");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  sp<NiNode> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiNode__set00
static int tolua_gamebryo_sp_NiNode__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiNode>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiNode",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiNode>* self = (sp<NiNode>*)  tolua_tousertype(tolua_S,1,0);
  NiNode* tolua_var_4 = ((NiNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_4);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: dcast of class  sp<NiNode> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiNode__dcast00
static int tolua_gamebryo_sp_NiNode__dcast00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiNode>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiObject* pkObj = ((NiObject*)  tolua_tousertype(tolua_S,2,0));
 {
  NiNode* tolua_ret = (NiNode*)  sp<NiNode>::dcast(pkObj);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiNode");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'dcast'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDimmer of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_SetDimmer00
static int tolua_gamebryo_NiLight_SetDimmer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiLight",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiLight* self = (NiLight*)  tolua_tousertype(tolua_S,1,0);
  float fDimmer = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDimmer'",NULL);
#endif
 {
  self->SetDimmer(fDimmer);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDimmer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDimmer of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_GetDimmer00
static int tolua_gamebryo_NiLight_GetDimmer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiLight",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiLight* self = (const NiLight*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDimmer'",NULL);
#endif
 {
  float tolua_ret = (float)  self->GetDimmer();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDimmer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetAmbientColor of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_SetAmbientColor00
static int tolua_gamebryo_NiLight_SetAmbientColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiLight",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiLight* self = (NiLight*)  tolua_tousertype(tolua_S,1,0);
  const NiColor* kColor = ((const NiColor*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAmbientColor'",NULL);
#endif
 {
  self->SetAmbientColor(*kColor);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetAmbientColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAmbientColor of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_GetAmbientColor00
static int tolua_gamebryo_NiLight_GetAmbientColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiLight",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiLight* self = (const NiLight*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAmbientColor'",NULL);
#endif
 {
  const NiColor& tolua_ret = (const NiColor&)  self->GetAmbientColor();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const NiColor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAmbientColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDiffuseColor of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_SetDiffuseColor00
static int tolua_gamebryo_NiLight_SetDiffuseColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiLight",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiLight* self = (NiLight*)  tolua_tousertype(tolua_S,1,0);
  const NiColor* kColor = ((const NiColor*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDiffuseColor'",NULL);
#endif
 {
  self->SetDiffuseColor(*kColor);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDiffuseColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDiffuseColor of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_GetDiffuseColor00
static int tolua_gamebryo_NiLight_GetDiffuseColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiLight",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiLight* self = (const NiLight*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDiffuseColor'",NULL);
#endif
 {
  const NiColor& tolua_ret = (const NiColor&)  self->GetDiffuseColor();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const NiColor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDiffuseColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpecularColor of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_SetSpecularColor00
static int tolua_gamebryo_NiLight_SetSpecularColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiLight",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiLight* self = (NiLight*)  tolua_tousertype(tolua_S,1,0);
  const NiColor* kColor = ((const NiColor*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpecularColor'",NULL);
#endif
 {
  self->SetSpecularColor(*kColor);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpecularColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpecularColor of class  NiLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiLight_GetSpecularColor00
static int tolua_gamebryo_NiLight_GetSpecularColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiLight",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiLight* self = (const NiLight*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpecularColor'",NULL);
#endif
 {
  const NiColor& tolua_ret = (const NiColor&)  self->GetSpecularColor();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const NiColor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpecularColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiAmbientLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAmbientLight_new00
static int tolua_gamebryo_NiAmbientLight_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiAmbientLight",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiAmbientLight* tolua_ret = (NiAmbientLight*)  new NiAmbientLight();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiAmbientLight");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiAmbientLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAmbientLight_new00_local
static int tolua_gamebryo_NiAmbientLight_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiAmbientLight",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiAmbientLight* tolua_ret = (NiAmbientLight*)  new NiAmbientLight();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiAmbientLight");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  NiAmbientLight */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiAmbientLight_delete00
static int tolua_gamebryo_NiAmbientLight_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiAmbientLight",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiAmbientLight* self = (NiAmbientLight*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_new00
static int tolua_gamebryo_NiFogProperty_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiFogProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiFogProperty* tolua_ret = (NiFogProperty*)  new NiFogProperty();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiFogProperty");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_new00_local
static int tolua_gamebryo_NiFogProperty_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiFogProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiFogProperty* tolua_ret = (NiFogProperty*)  new NiFogProperty();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiFogProperty");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_delete00
static int tolua_gamebryo_NiFogProperty_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiFogProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiFogProperty* self = (NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFog of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_SetFog00
static int tolua_gamebryo_NiFogProperty_SetFog00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiFogProperty",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiFogProperty* self = (NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
  bool bFog = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFog'",NULL);
#endif
 {
  self->SetFog(bFog);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFog'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFog of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_GetFog00
static int tolua_gamebryo_NiFogProperty_GetFog00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiFogProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiFogProperty* self = (const NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFog'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->GetFog();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFog'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFogFunction of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_SetFogFunction00
static int tolua_gamebryo_NiFogProperty_SetFogFunction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiFogProperty",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiFogProperty* self = (NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
  NiFogProperty::FogFunction eFunc = ((NiFogProperty::FogFunction) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFogFunction'",NULL);
#endif
 {
  self->SetFogFunction(eFunc);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFogFunction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFogFunction of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_GetFogFunction00
static int tolua_gamebryo_NiFogProperty_GetFogFunction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiFogProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiFogProperty* self = (const NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFogFunction'",NULL);
#endif
 {
  NiFogProperty::FogFunction tolua_ret = (NiFogProperty::FogFunction)  self->GetFogFunction();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFogFunction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFogColor of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_SetFogColor00
static int tolua_gamebryo_NiFogProperty_SetFogColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiFogProperty",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiFogProperty* self = (NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
  const NiColor* kColor = ((const NiColor*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFogColor'",NULL);
#endif
 {
  self->SetFogColor(*kColor);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFogColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFogColor of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_GetFogColor00
static int tolua_gamebryo_NiFogProperty_GetFogColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiFogProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiFogProperty* self = (const NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFogColor'",NULL);
#endif
 {
  const NiColor& tolua_ret = (const NiColor&)  self->GetFogColor();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const NiColor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFogColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDepth of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_SetDepth00
static int tolua_gamebryo_NiFogProperty_SetDepth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiFogProperty",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiFogProperty* self = (NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
  float fDepth = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDepth'",NULL);
#endif
 {
  self->SetDepth(fDepth);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDepth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDepth of class  NiFogProperty */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFogProperty_GetDepth00
static int tolua_gamebryo_NiFogProperty_GetDepth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiFogProperty",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiFogProperty* self = (const NiFogProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDepth'",NULL);
#endif
 {
  float tolua_ret = (float)  self->GetDepth();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDepth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Update of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_Update00
static int tolua_gamebryo_NiActorManager_Update00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiActorManager",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiActorManager* self = (NiActorManager*)  tolua_tousertype(tolua_S,1,0);
  float fTime = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Update'",NULL);
#endif
 {
  self->Update(fTime);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Update'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTargetAnimation of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_GetTargetAnimation00
static int tolua_gamebryo_NiActorManager_GetTargetAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiActorManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiActorManager* self = (const NiActorManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTargetAnimation'",NULL);
#endif
 {
  unsigned int tolua_ret = ( unsigned int)  self->GetTargetAnimation();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTargetAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetTargetAnimation of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_SetTargetAnimation00
static int tolua_gamebryo_NiActorManager_SetTargetAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiActorManager",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiActorManager* self = (NiActorManager*)  tolua_tousertype(tolua_S,1,0);
  unsigned int eSequenceID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTargetAnimation'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->SetTargetAnimation(eSequenceID);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetTargetAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Reset of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_Reset00
static int tolua_gamebryo_NiActorManager_Reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiActorManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiActorManager* self = (NiActorManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Reset'",NULL);
#endif
 {
  self->Reset();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Reset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNIFRoot of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_GetNIFRoot00
static int tolua_gamebryo_NiActorManager_GetNIFRoot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiActorManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiActorManager* self = (const NiActorManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNIFRoot'",NULL);
#endif
 {
  NiAVObject* tolua_ret = (NiAVObject*)  self->GetNIFRoot();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiAVObject");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNIFRoot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindSequenceID of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_FindSequenceID00
static int tolua_gamebryo_NiActorManager_FindSequenceID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiActorManager",0,&tolua_err) ||
 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiActorManager* self = (const NiActorManager*)  tolua_tousertype(tolua_S,1,0);
  const char* pcName = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindSequenceID'",NULL);
#endif
 {
  unsigned int tolua_ret = ( unsigned int)  self->FindSequenceID(pcName);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FindSequenceID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPaused of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_IsPaused00
static int tolua_gamebryo_NiActorManager_IsPaused00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiActorManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiActorManager* self = (const NiActorManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPaused'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->IsPaused();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPaused'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPaused of class  NiActorManager */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiActorManager_SetPaused00
static int tolua_gamebryo_NiActorManager_SetPaused00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiActorManager",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiActorManager* self = (NiActorManager*)  tolua_tousertype(tolua_S,1,0);
  bool bIsPaused = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPaused'",NULL);
#endif
 {
  self->SetPaused(bIsPaused);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPaused'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_new00
static int tolua_gamebryo_NiCamera_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiCamera* tolua_ret = (NiCamera*)  new NiCamera();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiCamera");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_new00_local
static int tolua_gamebryo_NiCamera_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiCamera* tolua_ret = (NiCamera*)  new NiCamera();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiCamera");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_delete00
static int tolua_gamebryo_NiCamera_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiCamera* self = (NiCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LookAtWorldPoint of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_LookAtWorldPoint00
static int tolua_gamebryo_NiCamera_LookAtWorldPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiPoint3",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const NiPoint3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiCamera* self = (NiCamera*)  tolua_tousertype(tolua_S,1,0);
  const NiPoint3* kWorldPt = ((const NiPoint3*)  tolua_tousertype(tolua_S,2,0));
  const NiPoint3* kWorldUp = ((const NiPoint3*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LookAtWorldPoint'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->LookAtWorldPoint(*kWorldPt,*kWorldUp);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LookAtWorldPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetViewFrustum of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_SetViewFrustum00
static int tolua_gamebryo_NiCamera_SetViewFrustum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiFrustum",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiCamera* self = (NiCamera*)  tolua_tousertype(tolua_S,1,0);
  const NiFrustum* kFrustum = ((const NiFrustum*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetViewFrustum'",NULL);
#endif
 {
  self->SetViewFrustum(*kFrustum);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetViewFrustum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetViewFrustum of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_GetViewFrustum00
static int tolua_gamebryo_NiCamera_GetViewFrustum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiCamera",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiCamera* self = (const NiCamera*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetViewFrustum'",NULL);
#endif
 {
  const NiFrustum& tolua_ret = (const NiFrustum&)  self->GetViewFrustum();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const NiFrustum");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetViewFrustum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiCamera_LookAtWorldPoint of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_LookAtWorldPoint01
static int tolua_gamebryo_NiCamera_LookAtWorldPoint01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiPoint3",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  NiCamera* self = (NiCamera*)  tolua_tousertype(tolua_S,1,0);
  NiPoint3 pt = *((NiPoint3*)  tolua_tousertype(tolua_S,2,0));
  double hori = ((double)  tolua_tonumber(tolua_S,3,0));
  double vert = ((double)  tolua_tonumber(tolua_S,4,0));
  double dist = ((double)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiCamera_LookAtWorldPoint'",NULL);
#endif
 {
  NiCamera_LookAtWorldPoint(self,pt,hori,vert,dist);
 }
 }
 return 0;
tolua_lerror:
 return tolua_gamebryo_NiCamera_LookAtWorldPoint00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiCamera_LookAtObject of class  NiCamera */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiCamera_LookAtObject00
static int tolua_gamebryo_NiCamera_LookAtObject00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiAVObject",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiCamera* self = (NiCamera*)  tolua_tousertype(tolua_S,1,0);
  NiAVObject* target = ((NiAVObject*)  tolua_tousertype(tolua_S,2,0));
  double hori = ((double)  tolua_tonumber(tolua_S,3,0));
  double vert = ((double)  tolua_tonumber(tolua_S,4,0));
  double dist = ((double)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NiCamera_LookAtObject'",NULL);
#endif
 {
  NiCamera_LookAtObject(self,target,hori,vert,dist);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LookAtObject'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFrustum_new00
static int tolua_gamebryo_NiFrustum_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiFrustum",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  float fLeft = ((float)  tolua_tonumber(tolua_S,2,0));
  float fRight = ((float)  tolua_tonumber(tolua_S,3,0));
  float fTop = ((float)  tolua_tonumber(tolua_S,4,0));
  float fBottom = ((float)  tolua_tonumber(tolua_S,5,0));
  float fNear = ((float)  tolua_tonumber(tolua_S,6,0));
  float fFar = ((float)  tolua_tonumber(tolua_S,7,0));
 {
  NiFrustum* tolua_ret = (NiFrustum*)  new NiFrustum(fLeft,fRight,fTop,fBottom,fNear,fFar);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiFrustum");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFrustum_new00_local
static int tolua_gamebryo_NiFrustum_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiFrustum",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  float fLeft = ((float)  tolua_tonumber(tolua_S,2,0));
  float fRight = ((float)  tolua_tonumber(tolua_S,3,0));
  float fTop = ((float)  tolua_tonumber(tolua_S,4,0));
  float fBottom = ((float)  tolua_tonumber(tolua_S,5,0));
  float fNear = ((float)  tolua_tonumber(tolua_S,6,0));
  float fFar = ((float)  tolua_tonumber(tolua_S,7,0));
 {
  NiFrustum* tolua_ret = (NiFrustum*)  new NiFrustum(fLeft,fRight,fTop,fBottom,fNear,fFar);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiFrustum");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiFrustum_delete00
static int tolua_gamebryo_NiFrustum_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiFrustum",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_fLeft of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_get_NiFrustum_m_fLeft
static int tolua_get_NiFrustum_m_fLeft(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fLeft'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->m_fLeft);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_fLeft of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_set_NiFrustum_m_fLeft
static int tolua_set_NiFrustum_m_fLeft(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fLeft'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_fLeft = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_fRight of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_get_NiFrustum_m_fRight
static int tolua_get_NiFrustum_m_fRight(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fRight'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->m_fRight);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_fRight of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_set_NiFrustum_m_fRight
static int tolua_set_NiFrustum_m_fRight(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fRight'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_fRight = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_fTop of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_get_NiFrustum_m_fTop
static int tolua_get_NiFrustum_m_fTop(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fTop'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->m_fTop);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_fTop of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_set_NiFrustum_m_fTop
static int tolua_set_NiFrustum_m_fTop(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fTop'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_fTop = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_fBottom of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_get_NiFrustum_m_fBottom
static int tolua_get_NiFrustum_m_fBottom(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fBottom'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->m_fBottom);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_fBottom of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_set_NiFrustum_m_fBottom
static int tolua_set_NiFrustum_m_fBottom(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fBottom'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_fBottom = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_fNear of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_get_NiFrustum_m_fNear
static int tolua_get_NiFrustum_m_fNear(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fNear'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->m_fNear);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_fNear of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_set_NiFrustum_m_fNear
static int tolua_set_NiFrustum_m_fNear(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fNear'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_fNear = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_fFar of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_get_NiFrustum_m_fFar
static int tolua_get_NiFrustum_m_fFar(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fFar'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->m_fFar);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_fFar of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_set_NiFrustum_m_fFar
static int tolua_set_NiFrustum_m_fFar(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_fFar'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_fFar = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_bOrtho of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_get_NiFrustum_m_bOrtho
static int tolua_get_NiFrustum_m_bOrtho(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_bOrtho'",NULL);
#endif
 tolua_pushboolean(tolua_S,(bool)self->m_bOrtho);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_bOrtho of class  NiFrustum */
#ifndef TOLUA_DISABLE_tolua_set_NiFrustum_m_bOrtho
static int tolua_set_NiFrustum_m_bOrtho(lua_State* tolua_S)
{
  NiFrustum* self = (NiFrustum*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_bOrtho'",NULL);
 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_bOrtho = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* function: _EE_DELETE */
#ifndef TOLUA_DISABLE_tolua_gamebryo_EE_DELETE00
static int tolua_gamebryo_EE_DELETE00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiPoint3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiPoint3* pObject = ((NiPoint3*)  tolua_tousertype(tolua_S,1,0));
 {
  _EE_DELETE(pObject);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EE_DELETE'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: _EE_DELETE */
#ifndef TOLUA_DISABLE_tolua_gamebryo_EE_DELETE01
static int tolua_gamebryo_EE_DELETE01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  NiColor* pObject = ((NiColor*)  tolua_tousertype(tolua_S,1,0));
 {
  _EE_DELETE(pObject);
 }
 }
 return 0;
tolua_lerror:
 return tolua_gamebryo_EE_DELETE00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ptr<NiFrustum> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiFrustum__new00
static int tolua_gamebryo_ptr_NiFrustum__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiFrustum>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiFrustum>* tolua_ret = (ptr<NiFrustum>*)  new ptr<NiFrustum>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ptr<NiFrustum>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ptr<NiFrustum> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiFrustum__new00_local
static int tolua_gamebryo_ptr_NiFrustum__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiFrustum>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiFrustum>* tolua_ret = (ptr<NiFrustum>*)  new ptr<NiFrustum>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"ptr<NiFrustum>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  ptr<NiFrustum> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiFrustum__delete00
static int tolua_gamebryo_ptr_NiFrustum__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiFrustum>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiFrustum>* self = (ptr<NiFrustum>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  ptr<NiFrustum> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiFrustum__put00
static int tolua_gamebryo_ptr_NiFrustum__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiFrustum>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiFrustum>* self = (ptr<NiFrustum>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  ptr<NiFrustum> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiFrustum__get00
static int tolua_gamebryo_ptr_NiFrustum__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiFrustum>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiFrustum>* self = (ptr<NiFrustum>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiFrustum* tolua_ret = (NiFrustum*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiFrustum");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  ptr<NiFrustum> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiFrustum__set00
static int tolua_gamebryo_ptr_NiFrustum__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiFrustum>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiFrustum",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiFrustum>* self = (ptr<NiFrustum>*)  tolua_tousertype(tolua_S,1,0);
  NiFrustum* tolua_var_5 = ((NiFrustum*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_5);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ptr<NiPoint3> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPoint3__new00
static int tolua_gamebryo_ptr_NiPoint3__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiPoint3>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiPoint3>* tolua_ret = (ptr<NiPoint3>*)  new ptr<NiPoint3>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ptr<NiPoint3>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ptr<NiPoint3> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPoint3__new00_local
static int tolua_gamebryo_ptr_NiPoint3__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiPoint3>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiPoint3>* tolua_ret = (ptr<NiPoint3>*)  new ptr<NiPoint3>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"ptr<NiPoint3>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  ptr<NiPoint3> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPoint3__delete00
static int tolua_gamebryo_ptr_NiPoint3__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPoint3>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPoint3>* self = (ptr<NiPoint3>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  ptr<NiPoint3> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPoint3__put00
static int tolua_gamebryo_ptr_NiPoint3__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPoint3>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPoint3>* self = (ptr<NiPoint3>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  ptr<NiPoint3> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPoint3__get00
static int tolua_gamebryo_ptr_NiPoint3__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPoint3>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPoint3>* self = (ptr<NiPoint3>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiPoint3* tolua_ret = (NiPoint3*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiPoint3");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  ptr<NiPoint3> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPoint3__set00
static int tolua_gamebryo_ptr_NiPoint3__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPoint3>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiPoint3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPoint3>* self = (ptr<NiPoint3>*)  tolua_tousertype(tolua_S,1,0);
  NiPoint3* tolua_var_6 = ((NiPoint3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_6);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ptr<NiPNGReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPNGReader__new00
static int tolua_gamebryo_ptr_NiPNGReader__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiPNGReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiPNGReader>* tolua_ret = (ptr<NiPNGReader>*)  new ptr<NiPNGReader>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ptr<NiPNGReader>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ptr<NiPNGReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPNGReader__new00_local
static int tolua_gamebryo_ptr_NiPNGReader__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiPNGReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiPNGReader>* tolua_ret = (ptr<NiPNGReader>*)  new ptr<NiPNGReader>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"ptr<NiPNGReader>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  ptr<NiPNGReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPNGReader__delete00
static int tolua_gamebryo_ptr_NiPNGReader__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPNGReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPNGReader>* self = (ptr<NiPNGReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  ptr<NiPNGReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPNGReader__put00
static int tolua_gamebryo_ptr_NiPNGReader__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPNGReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPNGReader>* self = (ptr<NiPNGReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  ptr<NiPNGReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPNGReader__get00
static int tolua_gamebryo_ptr_NiPNGReader__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPNGReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPNGReader>* self = (ptr<NiPNGReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiPNGReader* tolua_ret = (NiPNGReader*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiPNGReader");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  ptr<NiPNGReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiPNGReader__set00
static int tolua_gamebryo_ptr_NiPNGReader__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiPNGReader>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiPNGReader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiPNGReader>* self = (ptr<NiPNGReader>*)  tolua_tousertype(tolua_S,1,0);
  NiPNGReader* tolua_var_7 = ((NiPNGReader*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_7);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ptr<NiDDSReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiDDSReader__new00
static int tolua_gamebryo_ptr_NiDDSReader__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiDDSReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiDDSReader>* tolua_ret = (ptr<NiDDSReader>*)  new ptr<NiDDSReader>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ptr<NiDDSReader>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ptr<NiDDSReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiDDSReader__new00_local
static int tolua_gamebryo_ptr_NiDDSReader__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiDDSReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiDDSReader>* tolua_ret = (ptr<NiDDSReader>*)  new ptr<NiDDSReader>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"ptr<NiDDSReader>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  ptr<NiDDSReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiDDSReader__delete00
static int tolua_gamebryo_ptr_NiDDSReader__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiDDSReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiDDSReader>* self = (ptr<NiDDSReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  ptr<NiDDSReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiDDSReader__put00
static int tolua_gamebryo_ptr_NiDDSReader__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiDDSReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiDDSReader>* self = (ptr<NiDDSReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  ptr<NiDDSReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiDDSReader__get00
static int tolua_gamebryo_ptr_NiDDSReader__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiDDSReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiDDSReader>* self = (ptr<NiDDSReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiDDSReader* tolua_ret = (NiDDSReader*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiDDSReader");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  ptr<NiDDSReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiDDSReader__set00
static int tolua_gamebryo_ptr_NiDDSReader__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiDDSReader>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiDDSReader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiDDSReader>* self = (ptr<NiDDSReader>*)  tolua_tousertype(tolua_S,1,0);
  NiDDSReader* tolua_var_8 = ((NiDDSReader*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_8);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ptr<NiTGAReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiTGAReader__new00
static int tolua_gamebryo_ptr_NiTGAReader__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiTGAReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiTGAReader>* tolua_ret = (ptr<NiTGAReader>*)  new ptr<NiTGAReader>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ptr<NiTGAReader>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ptr<NiTGAReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiTGAReader__new00_local
static int tolua_gamebryo_ptr_NiTGAReader__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiTGAReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiTGAReader>* tolua_ret = (ptr<NiTGAReader>*)  new ptr<NiTGAReader>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"ptr<NiTGAReader>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  ptr<NiTGAReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiTGAReader__delete00
static int tolua_gamebryo_ptr_NiTGAReader__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiTGAReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiTGAReader>* self = (ptr<NiTGAReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  ptr<NiTGAReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiTGAReader__put00
static int tolua_gamebryo_ptr_NiTGAReader__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiTGAReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiTGAReader>* self = (ptr<NiTGAReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  ptr<NiTGAReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiTGAReader__get00
static int tolua_gamebryo_ptr_NiTGAReader__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiTGAReader>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiTGAReader>* self = (ptr<NiTGAReader>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiTGAReader* tolua_ret = (NiTGAReader*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiTGAReader");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  ptr<NiTGAReader> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiTGAReader__set00
static int tolua_gamebryo_ptr_NiTGAReader__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiTGAReader>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiTGAReader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiTGAReader>* self = (ptr<NiTGAReader>*)  tolua_tousertype(tolua_S,1,0);
  NiTGAReader* tolua_var_9 = ((NiTGAReader*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_9);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  ptr<NiColor> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiColor__new00
static int tolua_gamebryo_ptr_NiColor__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiColor>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiColor>* tolua_ret = (ptr<NiColor>*)  new ptr<NiColor>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ptr<NiColor>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  ptr<NiColor> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiColor__new00_local
static int tolua_gamebryo_ptr_NiColor__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"ptr<NiColor>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ptr<NiColor>* tolua_ret = (ptr<NiColor>*)  new ptr<NiColor>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"ptr<NiColor>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  ptr<NiColor> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiColor__delete00
static int tolua_gamebryo_ptr_NiColor__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiColor>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiColor>* self = (ptr<NiColor>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  ptr<NiColor> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiColor__put00
static int tolua_gamebryo_ptr_NiColor__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiColor>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiColor>* self = (ptr<NiColor>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  ptr<NiColor> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiColor__get00
static int tolua_gamebryo_ptr_NiColor__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiColor>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiColor>* self = (ptr<NiColor>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiColor* tolua_ret = (NiColor*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiColor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  ptr<NiColor> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ptr_NiColor__set00
static int tolua_gamebryo_ptr_NiColor__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"ptr<NiColor>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  ptr<NiColor>* self = (ptr<NiColor>*)  tolua_tousertype(tolua_S,1,0);
  NiColor* tolua_var_10 = ((NiColor*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_10);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__new00
static int tolua_gamebryo_sp_NiDX9Renderer__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiDX9Renderer>* tolua_ret = (sp<NiDX9Renderer>*)  new sp<NiDX9Renderer>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"sp<NiDX9Renderer>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__new00_local
static int tolua_gamebryo_sp_NiDX9Renderer__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiDX9Renderer>* tolua_ret = (sp<NiDX9Renderer>*)  new sp<NiDX9Renderer>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"sp<NiDX9Renderer>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__delete00
static int tolua_gamebryo_sp_NiDX9Renderer__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDX9Renderer>* self = (sp<NiDX9Renderer>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__put00
static int tolua_gamebryo_sp_NiDX9Renderer__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDX9Renderer>* self = (sp<NiDX9Renderer>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__get00
static int tolua_gamebryo_sp_NiDX9Renderer__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDX9Renderer>* self = (sp<NiDX9Renderer>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiDX9Renderer* tolua_ret = (NiDX9Renderer*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiDX9Renderer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__set00
static int tolua_gamebryo_sp_NiDX9Renderer__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiDX9Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDX9Renderer>* self = (sp<NiDX9Renderer>*)  tolua_tousertype(tolua_S,1,0);
  NiDX9Renderer* tolua_var_11 = ((NiDX9Renderer*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_11);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetParam of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__GetParam00
static int tolua_gamebryo_sp_NiDX9Renderer__GetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDX9Renderer>* self = (sp<NiDX9Renderer>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetParam'",NULL);
#endif
 {
  int tolua_ret = (int)  self->GetParam();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetParam of class  sp<NiDX9Renderer> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDX9Renderer__SetParam00
static int tolua_gamebryo_sp_NiDX9Renderer__SetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDX9Renderer>",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDX9Renderer>* self = (sp<NiDX9Renderer>*)  tolua_tousertype(tolua_S,1,0);
  int dwParam = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetParam'",NULL);
#endif
 {
  self->SetParam(dwParam);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__new00
static int tolua_gamebryo_sp_NiCamera__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiCamera>* tolua_ret = (sp<NiCamera>*)  new sp<NiCamera>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"sp<NiCamera>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__new00_local
static int tolua_gamebryo_sp_NiCamera__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiCamera>* tolua_ret = (sp<NiCamera>*)  new sp<NiCamera>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"sp<NiCamera>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__delete00
static int tolua_gamebryo_sp_NiCamera__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiCamera>* self = (sp<NiCamera>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__put00
static int tolua_gamebryo_sp_NiCamera__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiCamera>* self = (sp<NiCamera>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__get00
static int tolua_gamebryo_sp_NiCamera__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiCamera>* self = (sp<NiCamera>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiCamera* tolua_ret = (NiCamera*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiCamera");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__set00
static int tolua_gamebryo_sp_NiCamera__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiCamera",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiCamera>* self = (sp<NiCamera>*)  tolua_tousertype(tolua_S,1,0);
  NiCamera* tolua_var_12 = ((NiCamera*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_12);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetParam of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__GetParam00
static int tolua_gamebryo_sp_NiCamera__GetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiCamera>* self = (sp<NiCamera>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetParam'",NULL);
#endif
 {
  int tolua_ret = (int)  self->GetParam();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetParam of class  sp<NiCamera> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiCamera__SetParam00
static int tolua_gamebryo_sp_NiCamera__SetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiCamera>",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiCamera>* self = (sp<NiCamera>*)  tolua_tousertype(tolua_S,1,0);
  int dwParam = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetParam'",NULL);
#endif
 {
  self->SetParam(dwParam);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__new00
static int tolua_gamebryo_sp_NiDevImageConverter__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiDevImageConverter>* tolua_ret = (sp<NiDevImageConverter>*)  new sp<NiDevImageConverter>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"sp<NiDevImageConverter>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__new00_local
static int tolua_gamebryo_sp_NiDevImageConverter__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiDevImageConverter>* tolua_ret = (sp<NiDevImageConverter>*)  new sp<NiDevImageConverter>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"sp<NiDevImageConverter>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__delete00
static int tolua_gamebryo_sp_NiDevImageConverter__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDevImageConverter>* self = (sp<NiDevImageConverter>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__put00
static int tolua_gamebryo_sp_NiDevImageConverter__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDevImageConverter>* self = (sp<NiDevImageConverter>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__get00
static int tolua_gamebryo_sp_NiDevImageConverter__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDevImageConverter>* self = (sp<NiDevImageConverter>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiDevImageConverter* tolua_ret = (NiDevImageConverter*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiDevImageConverter");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__set00
static int tolua_gamebryo_sp_NiDevImageConverter__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiDevImageConverter",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDevImageConverter>* self = (sp<NiDevImageConverter>*)  tolua_tousertype(tolua_S,1,0);
  NiDevImageConverter* tolua_var_13 = ((NiDevImageConverter*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_13);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetParam of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__GetParam00
static int tolua_gamebryo_sp_NiDevImageConverter__GetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDevImageConverter>* self = (sp<NiDevImageConverter>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetParam'",NULL);
#endif
 {
  int tolua_ret = (int)  self->GetParam();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetParam of class  sp<NiDevImageConverter> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiDevImageConverter__SetParam00
static int tolua_gamebryo_sp_NiDevImageConverter__SetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiDevImageConverter>",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiDevImageConverter>* self = (sp<NiDevImageConverter>*)  tolua_tousertype(tolua_S,1,0);
  int dwParam = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetParam'",NULL);
#endif
 {
  self->SetParam(dwParam);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__new00
static int tolua_gamebryo_sp_NiAlphaAccumulator__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiAlphaAccumulator>* tolua_ret = (sp<NiAlphaAccumulator>*)  new sp<NiAlphaAccumulator>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"sp<NiAlphaAccumulator>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__new00_local
static int tolua_gamebryo_sp_NiAlphaAccumulator__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  sp<NiAlphaAccumulator>* tolua_ret = (sp<NiAlphaAccumulator>*)  new sp<NiAlphaAccumulator>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"sp<NiAlphaAccumulator>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__delete00
static int tolua_gamebryo_sp_NiAlphaAccumulator__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiAlphaAccumulator>* self = (sp<NiAlphaAccumulator>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: put of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__put00
static int tolua_gamebryo_sp_NiAlphaAccumulator__put00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiAlphaAccumulator>* self = (sp<NiAlphaAccumulator>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'put'",NULL);
#endif
 {
  self->put();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'put'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__get00
static int tolua_gamebryo_sp_NiAlphaAccumulator__get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiAlphaAccumulator>* self = (sp<NiAlphaAccumulator>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  NiAlphaAccumulator* tolua_ret = (NiAlphaAccumulator*)  self->get();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiAlphaAccumulator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__set00
static int tolua_gamebryo_sp_NiAlphaAccumulator__set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiAlphaAccumulator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiAlphaAccumulator>* self = (sp<NiAlphaAccumulator>*)  tolua_tousertype(tolua_S,1,0);
  NiAlphaAccumulator* tolua_var_14 = ((NiAlphaAccumulator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(tolua_var_14);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetParam of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__GetParam00
static int tolua_gamebryo_sp_NiAlphaAccumulator__GetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiAlphaAccumulator>* self = (sp<NiAlphaAccumulator>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetParam'",NULL);
#endif
 {
  int tolua_ret = (int)  self->GetParam();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetParam of class  sp<NiAlphaAccumulator> */
#ifndef TOLUA_DISABLE_tolua_gamebryo_sp_NiAlphaAccumulator__SetParam00
static int tolua_gamebryo_sp_NiAlphaAccumulator__SetParam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"sp<NiAlphaAccumulator>",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  sp<NiAlphaAccumulator>* self = (sp<NiAlphaAccumulator>*)  tolua_tousertype(tolua_S,1,0);
  int dwParam = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetParam'",NULL);
#endif
 {
  self->SetParam(dwParam);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetParam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiPNGReader */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiPNGReader_new00
static int tolua_gamebryo_NiPNGReader_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiPNGReader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiPNGReader* tolua_ret = (NiPNGReader*)  new NiPNGReader();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiPNGReader");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiPNGReader */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiPNGReader_new00_local
static int tolua_gamebryo_NiPNGReader_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiPNGReader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiPNGReader* tolua_ret = (NiPNGReader*)  new NiPNGReader();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiPNGReader");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetImageConverter of class  NiImageConverter */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiImageConverter_SetImageConverter00
static int tolua_gamebryo_NiImageConverter_SetImageConverter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiImageConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiImageConverter",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiImageConverter* tolua_var_15 = ((NiImageConverter*)  tolua_tousertype(tolua_S,2,0));
 {
  NiImageConverter::SetImageConverter(tolua_var_15);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetImageConverter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiDevImageConverter */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiDevImageConverter_new00
static int tolua_gamebryo_NiDevImageConverter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiDevImageConverter",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiDevImageConverter* tolua_ret = (NiDevImageConverter*)  new NiDevImageConverter();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiDevImageConverter");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiDevImageConverter */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiDevImageConverter_new00_local
static int tolua_gamebryo_NiDevImageConverter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiDevImageConverter",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiDevImageConverter* tolua_ret = (NiDevImageConverter*)  new NiDevImageConverter();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiDevImageConverter");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddReader of class  NiDevImageConverter */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiDevImageConverter_AddReader00
static int tolua_gamebryo_NiDevImageConverter_AddReader00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiDevImageConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiImageReader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiDevImageConverter* self = (NiDevImageConverter*)  tolua_tousertype(tolua_S,1,0);
  NiImageReader* tolua_var_16 = ((NiImageReader*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddReader'",NULL);
#endif
 {
  self->AddReader(tolua_var_16);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddReader'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDriverInfo of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_GetDriverInfo00
static int tolua_gamebryo_NiRenderer_GetDriverInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiRenderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiRenderer* self = (const NiRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDriverInfo'",NULL);
#endif
 {
  const char* tolua_ret = (const char*)  self->GetDriverInfo();
 tolua_pushstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDriverInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFrameID of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_GetFrameID00
static int tolua_gamebryo_NiRenderer_GetFrameID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiRenderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiRenderer* self = (const NiRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFrameID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->GetFrameID();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFrameID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BeginFrame of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_BeginFrame00
static int tolua_gamebryo_NiRenderer_BeginFrame00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BeginFrame'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->BeginFrame();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BeginFrame'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EndFrame of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_EndFrame00
static int tolua_gamebryo_NiRenderer_EndFrame00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EndFrame'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->EndFrame();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EndFrame'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DisplayFrame of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_DisplayFrame00
static int tolua_gamebryo_NiRenderer_DisplayFrame00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DisplayFrame'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->DisplayFrame();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DisplayFrame'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCameraData of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_SetCameraData00
static int tolua_gamebryo_NiRenderer_SetCameraData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiCamera",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
  const NiCamera* pkCamera = ((const NiCamera*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCameraData'",NULL);
#endif
 {
  self->SetCameraData(pkCamera);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCameraData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BeginUsingDefaultRenderTargetGroup of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_BeginUsingDefaultRenderTargetGroup00
static int tolua_gamebryo_NiRenderer_BeginUsingDefaultRenderTargetGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int uiClearMode = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BeginUsingDefaultRenderTargetGroup'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->BeginUsingDefaultRenderTargetGroup(uiClearMode);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BeginUsingDefaultRenderTargetGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EndUsingRenderTargetGroup of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_EndUsingRenderTargetGroup00
static int tolua_gamebryo_NiRenderer_EndUsingRenderTargetGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EndUsingRenderTargetGroup'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->EndUsingRenderTargetGroup();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EndUsingRenderTargetGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRenderer of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_GetRenderer00
static int tolua_gamebryo_NiRenderer_GetRenderer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiRenderer* tolua_ret = (NiRenderer*)  NiRenderer::GetRenderer();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiRenderer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRenderer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSorter of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_SetSorter00
static int tolua_gamebryo_NiRenderer_SetSorter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiAccumulator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
  NiAccumulator* pkAccum = ((NiAccumulator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSorter'",NULL);
#endif
 {
  self->SetSorter(pkAccum);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSorter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBackgroundColor of class  NiRenderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiRenderer_SetBackgroundColor00
static int tolua_gamebryo_NiRenderer_SetBackgroundColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiRenderer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const NiColor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiRenderer* self = (NiRenderer*)  tolua_tousertype(tolua_S,1,0);
  const NiColor* kColor = ((const NiColor*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBackgroundColor'",NULL);
#endif
 {
  self->SetBackgroundColor(*kColor);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBackgroundColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NiDX9Renderer_Create of class  NiDX9Renderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiDX9Renderer_Create00
static int tolua_gamebryo_NiDX9Renderer_Create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiDX9Renderer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  int wnd = ((int)  tolua_tonumber(tolua_S,2,0));
  int flags = ((int)  tolua_tonumber(tolua_S,3,0));
 {
  NiDX9Renderer* tolua_ret = (NiDX9Renderer*)  NiDX9Renderer_Create(wnd,flags);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiDX9Renderer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetD3DDevice of class  NiDX9Renderer */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiDX9Renderer_GetD3DDevice00
static int tolua_gamebryo_NiDX9Renderer_GetD3DDevice00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiDX9Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiDX9Renderer* self = (const NiDX9Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetD3DDevice'",NULL);
#endif
 {
  IDirect3DDevice9* tolua_ret = (IDirect3DDevice9*)  self->GetD3DDevice();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"IDirect3DDevice9");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetD3DDevice'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMipmapByDefault of class  NiTexture */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiTexture_SetMipmapByDefault00
static int tolua_gamebryo_NiTexture_SetMipmapByDefault00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiTexture",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  bool tolua_var_17 = ((bool)  tolua_toboolean(tolua_S,2,0));
 {
  NiTexture::SetMipmapByDefault(tolua_var_17);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMipmapByDefault'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetUseMipmapping of class  NiSourceTexture */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiSourceTexture_SetUseMipmapping00
static int tolua_gamebryo_NiSourceTexture_SetUseMipmapping00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiSourceTexture",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  bool tolua_var_18 = ((bool)  tolua_toboolean(tolua_S,2,0));
 {
  NiSourceTexture::SetUseMipmapping(tolua_var_18);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetUseMipmapping'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  NiStream */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiStream_new00
static int tolua_gamebryo_NiStream_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiStream* tolua_ret = (NiStream*)  new NiStream();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiStream");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  NiStream */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiStream_new00_local
static int tolua_gamebryo_NiStream_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  NiStream* tolua_ret = (NiStream*)  new NiStream();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"NiStream");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  NiStream */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiStream_delete00
static int tolua_gamebryo_NiStream_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiStream* self = (NiStream*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetObjectCount of class  NiStream */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiStream_GetObjectCount00
static int tolua_gamebryo_NiStream_GetObjectCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiStream* self = (const NiStream*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetObjectCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->GetObjectCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetObjectCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetObjectAt of class  NiStream */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiStream_GetObjectAt00
static int tolua_gamebryo_NiStream_GetObjectAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const NiStream",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const NiStream* self = (const NiStream*)  tolua_tousertype(tolua_S,1,0);
  unsigned int i = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetObjectAt'",NULL);
#endif
 {
  NiObject* tolua_ret = (NiObject*)  self->GetObjectAt(i);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"NiObject");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetObjectAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Load of class  NiStream */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiStream_Load00
static int tolua_gamebryo_NiStream_Load00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiStream",0,&tolua_err) ||
 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiStream* self = (NiStream*)  tolua_tousertype(tolua_S,1,0);
  const char* pcFileName = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Load'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->Load(pcFileName);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Load'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: _EE_DELETE */
#ifndef TOLUA_DISABLE_tolua_gamebryo_EE_DELETE02
static int tolua_gamebryo_EE_DELETE02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  NiStream* pObject = ((NiStream*)  tolua_tousertype(tolua_S,1,0));
 {
  _EE_DELETE(pObject);
 }
 }
 return 0;
tolua_lerror:
 return tolua_gamebryo_EE_DELETE01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDefaultWorkingDirectory of class  NiMaterial */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiMaterial_SetDefaultWorkingDirectory00
static int tolua_gamebryo_NiMaterial_SetDefaultWorkingDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"NiMaterial",0,&tolua_err) ||
 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const char* tolua_var_19 = ((const char*)  tolua_tostring(tolua_S,2,0));
 {
  NiMaterial::SetDefaultWorkingDirectory(tolua_var_19);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDefaultWorkingDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: InitEngine */
#ifndef TOLUA_DISABLE_tolua_gamebryo_InitEngine00
static int tolua_gamebryo_InitEngine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isnoobj(tolua_S,1,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  InitEngine();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'InitEngine'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ReleaseEngine */
#ifndef TOLUA_DISABLE_tolua_gamebryo_ReleaseEngine00
static int tolua_gamebryo_ReleaseEngine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isnoobj(tolua_S,1,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  ReleaseEngine();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReleaseEngine'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: SetMemoryLog */
#ifndef TOLUA_DISABLE_tolua_gamebryo_SetMemoryLog00
static int tolua_gamebryo_SetMemoryLog00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  bool bOn = ((bool)  tolua_toboolean(tolua_S,1,0));
 {
  SetMemoryLog(bOn);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMemoryLog'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: _NiDrawScene_ */
#ifndef TOLUA_DISABLE_tolua_gamebryo_NiDrawScene00
static int tolua_gamebryo_NiDrawScene00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"NiCamera",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"NiAVObject",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  NiCamera* pkCamera = ((NiCamera*)  tolua_tousertype(tolua_S,1,0));
  NiAVObject* pkScene = ((NiAVObject*)  tolua_tousertype(tolua_S,2,0));
 {
  _NiDrawScene_(pkCamera,pkScene);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'NiDrawScene'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
int tolua_gamebryo_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
 tolua_module(tolua_S,"efd",0);
 tolua_beginmodule(tolua_S,"efd");
  tolua_cclass(tolua_S,"MemObject","efd::MemObject","",NULL);
  tolua_beginmodule(tolua_S,"MemObject");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Point3","efd::Point3","efd::MemObject",NULL);
  tolua_beginmodule(tolua_S,"Point3");
   tolua_variable(tolua_S,"x",tolua_get_efd__Point3_x,tolua_set_efd__Point3_x);
   tolua_variable(tolua_S,"y",tolua_get_efd__Point3_y,tolua_set_efd__Point3_y);
   tolua_variable(tolua_S,"z",tolua_get_efd__Point3_z,tolua_set_efd__Point3_z);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiColor","NiColor","",tolua_collect_NiColor);
 #else
 tolua_cclass(tolua_S,"NiColor","NiColor","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiColor");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiColor_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiColor_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiColor_new00_local);
  tolua_function(tolua_S,"new",tolua_gamebryo_NiColor_new01);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiColor_new01_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiColor_new01_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_NiColor_delete00);
  tolua_variable(tolua_S,"r",tolua_get_NiColor_r,tolua_set_NiColor_r);
  tolua_variable(tolua_S,"g",tolua_get_NiColor_g,tolua_set_NiColor_g);
  tolua_variable(tolua_S,"b",tolua_get_NiColor_b,tolua_set_NiColor_b);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiPoint3","NiPoint3","efd::Point3",tolua_collect_NiPoint3);
 #else
 tolua_cclass(tolua_S,"NiPoint3","NiPoint3","efd::Point3",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiPoint3");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiPoint3_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiPoint3_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiPoint3_new00_local);
  tolua_function(tolua_S,"new",tolua_gamebryo_NiPoint3_new01);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiPoint3_new01_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiPoint3_new01_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_NiPoint3_delete00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiRefObject","NiRefObject","NiMemObject",NULL);
 tolua_beginmodule(tolua_S,"NiRefObject");
  tolua_function(tolua_S,"IncRefCount",tolua_gamebryo_NiRefObject_IncRefCount00);
  tolua_function(tolua_S,"DecRefCount",tolua_gamebryo_NiRefObject_DecRefCount00);
  tolua_function(tolua_S,"GetRefCount",tolua_gamebryo_NiRefObject_GetRefCount00);
  tolua_function(tolua_S,"GetTotalObjectCount",tolua_gamebryo_NiRefObject_GetTotalObjectCount00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiRTTI","NiRTTI","",NULL);
 tolua_beginmodule(tolua_S,"NiRTTI");
  tolua_function(tolua_S,"GetName",tolua_gamebryo_NiRTTI_GetName00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiObject","NiObject","NiRefObject",NULL);
 tolua_beginmodule(tolua_S,"NiObject");
  tolua_function(tolua_S,"GetRTTI",tolua_gamebryo_NiObject_GetRTTI00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"sp_NiObject_","sp<NiObject>","",tolua_collect_sp_NiObject_);
 #else
 tolua_cclass(tolua_S,"sp_NiObject_","sp<NiObject>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"sp_NiObject_");
  tolua_function(tolua_S,"new",tolua_gamebryo_sp_NiObject__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_sp_NiObject__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_sp_NiObject__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_sp_NiObject__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_sp_NiObject__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_sp_NiObject__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_sp_NiObject__set00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiObjectNET","NiObjectNET","NiObject",NULL);
 tolua_beginmodule(tolua_S,"NiObjectNET");
  tolua_function(tolua_S,"GetName",tolua_gamebryo_NiObjectNET_GetName00);
  tolua_function(tolua_S,"SetName",tolua_gamebryo_NiObjectNET_SetName00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiProperty","NiProperty","NiObjectNET",NULL);
 tolua_beginmodule(tolua_S,"NiProperty");
  tolua_function(tolua_S,"Type",tolua_gamebryo_NiProperty_Type00);
  tolua_function(tolua_S,"Update",tolua_gamebryo_NiProperty_Update00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiAVObject","NiAVObject","NiObjectNET",NULL);
 tolua_beginmodule(tolua_S,"NiAVObject");
  tolua_function(tolua_S,"SetAppCulled",tolua_gamebryo_NiAVObject_SetAppCulled00);
  tolua_function(tolua_S,"GetAppCulled",tolua_gamebryo_NiAVObject_GetAppCulled00);
  tolua_function(tolua_S,"GetObjectByName",tolua_gamebryo_NiAVObject_GetObjectByName00);
  tolua_function(tolua_S,"SetTranslate",tolua_gamebryo_NiAVObject_SetTranslate00);
  tolua_function(tolua_S,"SetTranslate",tolua_gamebryo_NiAVObject_SetTranslate01);
  tolua_function(tolua_S,"SetScale",tolua_gamebryo_NiAVObject_SetScale00);
  tolua_function(tolua_S,"SetRotate",tolua_gamebryo_NiAVObject_SetRotate00);
  tolua_function(tolua_S,"Update",tolua_gamebryo_NiAVObject_Update00);
  tolua_function(tolua_S,"UpdateAll",tolua_gamebryo_NiAVObject_UpdateAll00);
  tolua_function(tolua_S,"UpdateProperties",tolua_gamebryo_NiAVObject_UpdateProperties00);
  tolua_function(tolua_S,"AttachProperty",tolua_gamebryo_NiAVObject_AttachProperty00);
  tolua_function(tolua_S,"DetachProperty",tolua_gamebryo_NiAVObject_DetachProperty00);
  tolua_function(tolua_S,"ToNiNode",tolua_gamebryo_NiAVObject_ToNiNode00);
  tolua_function(tolua_S,"ToNiTerrain",tolua_gamebryo_NiAVObject_ToNiTerrain00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiNode","NiNode","NiAVObject",tolua_collect_NiNode);
 #else
 tolua_cclass(tolua_S,"NiNode","NiNode","NiAVObject",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiNode");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiNode_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiNode_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiNode_new00_local);
  tolua_function(tolua_S,"CompactChildArray",tolua_gamebryo_NiNode_CompactChildArray00);
  tolua_function(tolua_S,"GetAt",tolua_gamebryo_NiNode_GetAt00);
  tolua_function(tolua_S,"GetChildCount",tolua_gamebryo_NiNode_GetChildCount00);
  tolua_function(tolua_S,"GetArrayCount",tolua_gamebryo_NiNode_GetArrayCount00);
  tolua_function(tolua_S,"AttachChild",tolua_gamebryo_NiNode_AttachChild00);
  tolua_function(tolua_S,"DetachChild",tolua_gamebryo_NiNode_DetachChild00);
  tolua_function(tolua_S,"GetEffectList",tolua_gamebryo_NiNode_GetEffectList00);
  tolua_function(tolua_S,"AttachEffect",tolua_gamebryo_NiNode_AttachEffect00);
  tolua_function(tolua_S,"DetachEffect",tolua_gamebryo_NiNode_DetachEffect00);
  tolua_function(tolua_S,"DetachAllEffects",tolua_gamebryo_NiNode_DetachAllEffects00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"sp_NiNode_","sp<NiNode>","",tolua_collect_sp_NiNode_);
 #else
 tolua_cclass(tolua_S,"sp_NiNode_","sp<NiNode>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"sp_NiNode_");
  tolua_function(tolua_S,"new",tolua_gamebryo_sp_NiNode__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_sp_NiNode__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_sp_NiNode__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_sp_NiNode__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_sp_NiNode__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_sp_NiNode__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_sp_NiNode__set00);
  tolua_function(tolua_S,"dcast",tolua_gamebryo_sp_NiNode__dcast00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiDynamicEffect","NiDynamicEffect","NiAVObject",NULL);
 tolua_beginmodule(tolua_S,"NiDynamicEffect");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiLight","NiLight","NiDynamicEffect",NULL);
 tolua_beginmodule(tolua_S,"NiLight");
  tolua_function(tolua_S,"SetDimmer",tolua_gamebryo_NiLight_SetDimmer00);
  tolua_function(tolua_S,"GetDimmer",tolua_gamebryo_NiLight_GetDimmer00);
  tolua_function(tolua_S,"SetAmbientColor",tolua_gamebryo_NiLight_SetAmbientColor00);
  tolua_function(tolua_S,"GetAmbientColor",tolua_gamebryo_NiLight_GetAmbientColor00);
  tolua_function(tolua_S,"SetDiffuseColor",tolua_gamebryo_NiLight_SetDiffuseColor00);
  tolua_function(tolua_S,"GetDiffuseColor",tolua_gamebryo_NiLight_GetDiffuseColor00);
  tolua_function(tolua_S,"SetSpecularColor",tolua_gamebryo_NiLight_SetSpecularColor00);
  tolua_function(tolua_S,"GetSpecularColor",tolua_gamebryo_NiLight_GetSpecularColor00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiAmbientLight","NiAmbientLight","NiLight",tolua_collect_NiAmbientLight);
 #else
 tolua_cclass(tolua_S,"NiAmbientLight","NiAmbientLight","NiLight",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiAmbientLight");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiAmbientLight_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiAmbientLight_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiAmbientLight_new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_NiAmbientLight_delete00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiFogProperty","NiFogProperty","NiProperty",tolua_collect_NiFogProperty);
 #else
 tolua_cclass(tolua_S,"NiFogProperty","NiFogProperty","NiProperty",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiFogProperty");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiFogProperty_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiFogProperty_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiFogProperty_new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_NiFogProperty_delete00);
  tolua_constant(tolua_S,"FOG_Z_LINEAR",NiFogProperty::FOG_Z_LINEAR);
  tolua_constant(tolua_S,"FOG_RANGE_SQ",NiFogProperty::FOG_RANGE_SQ);
  tolua_constant(tolua_S,"FOG_VERTEX_ALPHA",NiFogProperty::FOG_VERTEX_ALPHA);
  tolua_function(tolua_S,"SetFog",tolua_gamebryo_NiFogProperty_SetFog00);
  tolua_function(tolua_S,"GetFog",tolua_gamebryo_NiFogProperty_GetFog00);
  tolua_function(tolua_S,"SetFogFunction",tolua_gamebryo_NiFogProperty_SetFogFunction00);
  tolua_function(tolua_S,"GetFogFunction",tolua_gamebryo_NiFogProperty_GetFogFunction00);
  tolua_function(tolua_S,"SetFogColor",tolua_gamebryo_NiFogProperty_SetFogColor00);
  tolua_function(tolua_S,"GetFogColor",tolua_gamebryo_NiFogProperty_GetFogColor00);
  tolua_function(tolua_S,"SetDepth",tolua_gamebryo_NiFogProperty_SetDepth00);
  tolua_function(tolua_S,"GetDepth",tolua_gamebryo_NiFogProperty_GetDepth00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiActorManager","NiActorManager","",NULL);
 tolua_beginmodule(tolua_S,"NiActorManager");
  tolua_function(tolua_S,"Update",tolua_gamebryo_NiActorManager_Update00);
  tolua_function(tolua_S,"GetTargetAnimation",tolua_gamebryo_NiActorManager_GetTargetAnimation00);
  tolua_function(tolua_S,"SetTargetAnimation",tolua_gamebryo_NiActorManager_SetTargetAnimation00);
  tolua_function(tolua_S,"Reset",tolua_gamebryo_NiActorManager_Reset00);
  tolua_function(tolua_S,"GetNIFRoot",tolua_gamebryo_NiActorManager_GetNIFRoot00);
  tolua_function(tolua_S,"FindSequenceID",tolua_gamebryo_NiActorManager_FindSequenceID00);
  tolua_function(tolua_S,"IsPaused",tolua_gamebryo_NiActorManager_IsPaused00);
  tolua_function(tolua_S,"SetPaused",tolua_gamebryo_NiActorManager_SetPaused00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiCamera","NiCamera","NiAVObject",tolua_collect_NiCamera);
 #else
 tolua_cclass(tolua_S,"NiCamera","NiCamera","NiAVObject",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiCamera");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiCamera_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiCamera_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiCamera_new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_NiCamera_delete00);
  tolua_function(tolua_S,"LookAtWorldPoint",tolua_gamebryo_NiCamera_LookAtWorldPoint00);
  tolua_function(tolua_S,"SetViewFrustum",tolua_gamebryo_NiCamera_SetViewFrustum00);
  tolua_function(tolua_S,"GetViewFrustum",tolua_gamebryo_NiCamera_GetViewFrustum00);
  tolua_function(tolua_S,"LookAtWorldPoint",tolua_gamebryo_NiCamera_LookAtWorldPoint01);
  tolua_function(tolua_S,"LookAtObject",tolua_gamebryo_NiCamera_LookAtObject00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiFrustum","NiFrustum","",tolua_collect_NiFrustum);
 #else
 tolua_cclass(tolua_S,"NiFrustum","NiFrustum","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiFrustum");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiFrustum_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiFrustum_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiFrustum_new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_NiFrustum_delete00);
  tolua_variable(tolua_S,"m_fLeft",tolua_get_NiFrustum_m_fLeft,tolua_set_NiFrustum_m_fLeft);
  tolua_variable(tolua_S,"m_fRight",tolua_get_NiFrustum_m_fRight,tolua_set_NiFrustum_m_fRight);
  tolua_variable(tolua_S,"m_fTop",tolua_get_NiFrustum_m_fTop,tolua_set_NiFrustum_m_fTop);
  tolua_variable(tolua_S,"m_fBottom",tolua_get_NiFrustum_m_fBottom,tolua_set_NiFrustum_m_fBottom);
  tolua_variable(tolua_S,"m_fNear",tolua_get_NiFrustum_m_fNear,tolua_set_NiFrustum_m_fNear);
  tolua_variable(tolua_S,"m_fFar",tolua_get_NiFrustum_m_fFar,tolua_set_NiFrustum_m_fFar);
  tolua_variable(tolua_S,"m_bOrtho",tolua_get_NiFrustum_m_bOrtho,tolua_set_NiFrustum_m_bOrtho);
 tolua_endmodule(tolua_S);
 tolua_function(tolua_S,"EE_DELETE",tolua_gamebryo_EE_DELETE00);
 tolua_function(tolua_S,"EE_DELETE",tolua_gamebryo_EE_DELETE01);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"ptr_NiFrustum_","ptr<NiFrustum>","",tolua_collect_ptr_NiFrustum_);
 #else
 tolua_cclass(tolua_S,"ptr_NiFrustum_","ptr<NiFrustum>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"ptr_NiFrustum_");
  tolua_function(tolua_S,"new",tolua_gamebryo_ptr_NiFrustum__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_ptr_NiFrustum__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_ptr_NiFrustum__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_ptr_NiFrustum__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_ptr_NiFrustum__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_ptr_NiFrustum__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_ptr_NiFrustum__set00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"ptr_NiPoint3_","ptr<NiPoint3>","",tolua_collect_ptr_NiPoint3_);
 #else
 tolua_cclass(tolua_S,"ptr_NiPoint3_","ptr<NiPoint3>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"ptr_NiPoint3_");
  tolua_function(tolua_S,"new",tolua_gamebryo_ptr_NiPoint3__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_ptr_NiPoint3__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_ptr_NiPoint3__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_ptr_NiPoint3__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_ptr_NiPoint3__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_ptr_NiPoint3__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_ptr_NiPoint3__set00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"ptr_NiPNGReader_","ptr<NiPNGReader>","",tolua_collect_ptr_NiPNGReader_);
 #else
 tolua_cclass(tolua_S,"ptr_NiPNGReader_","ptr<NiPNGReader>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"ptr_NiPNGReader_");
  tolua_function(tolua_S,"new",tolua_gamebryo_ptr_NiPNGReader__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_ptr_NiPNGReader__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_ptr_NiPNGReader__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_ptr_NiPNGReader__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_ptr_NiPNGReader__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_ptr_NiPNGReader__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_ptr_NiPNGReader__set00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"ptr_NiDDSReader_","ptr<NiDDSReader>","",tolua_collect_ptr_NiDDSReader_);
 #else
 tolua_cclass(tolua_S,"ptr_NiDDSReader_","ptr<NiDDSReader>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"ptr_NiDDSReader_");
  tolua_function(tolua_S,"new",tolua_gamebryo_ptr_NiDDSReader__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_ptr_NiDDSReader__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_ptr_NiDDSReader__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_ptr_NiDDSReader__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_ptr_NiDDSReader__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_ptr_NiDDSReader__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_ptr_NiDDSReader__set00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"ptr_NiTGAReader_","ptr<NiTGAReader>","",tolua_collect_ptr_NiTGAReader_);
 #else
 tolua_cclass(tolua_S,"ptr_NiTGAReader_","ptr<NiTGAReader>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"ptr_NiTGAReader_");
  tolua_function(tolua_S,"new",tolua_gamebryo_ptr_NiTGAReader__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_ptr_NiTGAReader__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_ptr_NiTGAReader__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_ptr_NiTGAReader__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_ptr_NiTGAReader__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_ptr_NiTGAReader__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_ptr_NiTGAReader__set00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"ptr_NiColor_","ptr<NiColor>","",tolua_collect_ptr_NiColor_);
 #else
 tolua_cclass(tolua_S,"ptr_NiColor_","ptr<NiColor>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"ptr_NiColor_");
  tolua_function(tolua_S,"new",tolua_gamebryo_ptr_NiColor__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_ptr_NiColor__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_ptr_NiColor__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_ptr_NiColor__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_ptr_NiColor__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_ptr_NiColor__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_ptr_NiColor__set00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"sp_NiDX9Renderer_","sp<NiDX9Renderer>","",tolua_collect_sp_NiDX9Renderer_);
 #else
 tolua_cclass(tolua_S,"sp_NiDX9Renderer_","sp<NiDX9Renderer>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"sp_NiDX9Renderer_");
  tolua_function(tolua_S,"new",tolua_gamebryo_sp_NiDX9Renderer__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_sp_NiDX9Renderer__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_sp_NiDX9Renderer__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_sp_NiDX9Renderer__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_sp_NiDX9Renderer__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_sp_NiDX9Renderer__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_sp_NiDX9Renderer__set00);
  tolua_function(tolua_S,"GetParam",tolua_gamebryo_sp_NiDX9Renderer__GetParam00);
  tolua_function(tolua_S,"SetParam",tolua_gamebryo_sp_NiDX9Renderer__SetParam00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"sp_NiCamera_","sp<NiCamera>","",tolua_collect_sp_NiCamera_);
 #else
 tolua_cclass(tolua_S,"sp_NiCamera_","sp<NiCamera>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"sp_NiCamera_");
  tolua_function(tolua_S,"new",tolua_gamebryo_sp_NiCamera__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_sp_NiCamera__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_sp_NiCamera__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_sp_NiCamera__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_sp_NiCamera__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_sp_NiCamera__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_sp_NiCamera__set00);
  tolua_function(tolua_S,"GetParam",tolua_gamebryo_sp_NiCamera__GetParam00);
  tolua_function(tolua_S,"SetParam",tolua_gamebryo_sp_NiCamera__SetParam00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"sp_NiDevImageConverter_","sp<NiDevImageConverter>","",tolua_collect_sp_NiDevImageConverter_);
 #else
 tolua_cclass(tolua_S,"sp_NiDevImageConverter_","sp<NiDevImageConverter>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"sp_NiDevImageConverter_");
  tolua_function(tolua_S,"new",tolua_gamebryo_sp_NiDevImageConverter__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_sp_NiDevImageConverter__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_sp_NiDevImageConverter__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_sp_NiDevImageConverter__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_sp_NiDevImageConverter__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_sp_NiDevImageConverter__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_sp_NiDevImageConverter__set00);
  tolua_function(tolua_S,"GetParam",tolua_gamebryo_sp_NiDevImageConverter__GetParam00);
  tolua_function(tolua_S,"SetParam",tolua_gamebryo_sp_NiDevImageConverter__SetParam00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"sp_NiAlphaAccumulator_","sp<NiAlphaAccumulator>","",tolua_collect_sp_NiAlphaAccumulator_);
 #else
 tolua_cclass(tolua_S,"sp_NiAlphaAccumulator_","sp<NiAlphaAccumulator>","",NULL);
 #endif
 tolua_beginmodule(tolua_S,"sp_NiAlphaAccumulator_");
  tolua_function(tolua_S,"new",tolua_gamebryo_sp_NiAlphaAccumulator__new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_sp_NiAlphaAccumulator__new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_sp_NiAlphaAccumulator__new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_sp_NiAlphaAccumulator__delete00);
  tolua_function(tolua_S,"put",tolua_gamebryo_sp_NiAlphaAccumulator__put00);
  tolua_function(tolua_S,"get",tolua_gamebryo_sp_NiAlphaAccumulator__get00);
  tolua_function(tolua_S,"set",tolua_gamebryo_sp_NiAlphaAccumulator__set00);
  tolua_function(tolua_S,"GetParam",tolua_gamebryo_sp_NiAlphaAccumulator__GetParam00);
  tolua_function(tolua_S,"SetParam",tolua_gamebryo_sp_NiAlphaAccumulator__SetParam00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiImageReader","NiImageReader","NiRefObject",NULL);
 tolua_beginmodule(tolua_S,"NiImageReader");
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiPNGReader","NiPNGReader","NiImageReader",tolua_collect_NiPNGReader);
 #else
 tolua_cclass(tolua_S,"NiPNGReader","NiPNGReader","NiImageReader",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiPNGReader");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiPNGReader_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiPNGReader_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiPNGReader_new00_local);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiDDSReader","NiDDSReader","NiImageReader",NULL);
 tolua_beginmodule(tolua_S,"NiDDSReader");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiTGAReader","NiTGAReader","NiImageReader",NULL);
 tolua_beginmodule(tolua_S,"NiTGAReader");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiImageConverter","NiImageConverter","NiRefObject",NULL);
 tolua_beginmodule(tolua_S,"NiImageConverter");
  tolua_function(tolua_S,"SetImageConverter",tolua_gamebryo_NiImageConverter_SetImageConverter00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiDevImageConverter","NiDevImageConverter","NiImageConverter",tolua_collect_NiDevImageConverter);
 #else
 tolua_cclass(tolua_S,"NiDevImageConverter","NiDevImageConverter","NiImageConverter",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiDevImageConverter");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiDevImageConverter_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiDevImageConverter_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiDevImageConverter_new00_local);
  tolua_function(tolua_S,"AddReader",tolua_gamebryo_NiDevImageConverter_AddReader00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiAccumulator","NiAccumulator","",NULL);
 tolua_beginmodule(tolua_S,"NiAccumulator");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiBackToFrontAccumulator","NiBackToFrontAccumulator","NiAccumulator",NULL);
 tolua_beginmodule(tolua_S,"NiBackToFrontAccumulator");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiAlphaAccumulator","NiAlphaAccumulator","NiBackToFrontAccumulator",NULL);
 tolua_beginmodule(tolua_S,"NiAlphaAccumulator");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiRenderer","NiRenderer","NiObject",NULL);
 tolua_beginmodule(tolua_S,"NiRenderer");
  tolua_constant(tolua_S,"CLEAR_BACKBUFFER",NiRenderer::CLEAR_BACKBUFFER);
  tolua_constant(tolua_S,"CLEAR_STENCIL",NiRenderer::CLEAR_STENCIL);
  tolua_constant(tolua_S,"CLEAR_ZBUFFER",NiRenderer::CLEAR_ZBUFFER);
  tolua_constant(tolua_S,"CLEAR_NONE",NiRenderer::CLEAR_NONE);
  tolua_constant(tolua_S,"CLEAR_ALL",NiRenderer::CLEAR_ALL);
  tolua_function(tolua_S,"GetDriverInfo",tolua_gamebryo_NiRenderer_GetDriverInfo00);
  tolua_function(tolua_S,"GetFrameID",tolua_gamebryo_NiRenderer_GetFrameID00);
  tolua_function(tolua_S,"BeginFrame",tolua_gamebryo_NiRenderer_BeginFrame00);
  tolua_function(tolua_S,"EndFrame",tolua_gamebryo_NiRenderer_EndFrame00);
  tolua_function(tolua_S,"DisplayFrame",tolua_gamebryo_NiRenderer_DisplayFrame00);
  tolua_function(tolua_S,"SetCameraData",tolua_gamebryo_NiRenderer_SetCameraData00);
  tolua_function(tolua_S,"BeginUsingDefaultRenderTargetGroup",tolua_gamebryo_NiRenderer_BeginUsingDefaultRenderTargetGroup00);
  tolua_function(tolua_S,"EndUsingRenderTargetGroup",tolua_gamebryo_NiRenderer_EndUsingRenderTargetGroup00);
  tolua_function(tolua_S,"GetRenderer",tolua_gamebryo_NiRenderer_GetRenderer00);
  tolua_function(tolua_S,"SetSorter",tolua_gamebryo_NiRenderer_SetSorter00);
  tolua_function(tolua_S,"SetBackgroundColor",tolua_gamebryo_NiRenderer_SetBackgroundColor00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"IDirect3DDevice9","IDirect3DDevice9","",NULL);
 tolua_beginmodule(tolua_S,"IDirect3DDevice9");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiDX9Renderer","NiDX9Renderer","NiRenderer",NULL);
 tolua_beginmodule(tolua_S,"NiDX9Renderer");
  tolua_constant(tolua_S,"USE_NOFLAGS",NiDX9Renderer::USE_NOFLAGS);
  tolua_constant(tolua_S,"USE_MANUALDEPTHSTENCIL",NiDX9Renderer::USE_MANUALDEPTHSTENCIL);
  tolua_constant(tolua_S,"USE_FULLSCREEN",NiDX9Renderer::USE_FULLSCREEN);
  tolua_constant(tolua_S,"USE_STENCIL",NiDX9Renderer::USE_STENCIL);
  tolua_constant(tolua_S,"USE_16BITBUFFERS",NiDX9Renderer::USE_16BITBUFFERS);
  tolua_constant(tolua_S,"USE_MULTITHREADED",NiDX9Renderer::USE_MULTITHREADED);
  tolua_constant(tolua_S,"USE_FPU_PRESERVE",NiDX9Renderer::USE_FPU_PRESERVE);
  tolua_function(tolua_S,"Create",tolua_gamebryo_NiDX9Renderer_Create00);
  tolua_function(tolua_S,"GetD3DDevice",tolua_gamebryo_NiDX9Renderer_GetD3DDevice00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiTerrain","NiTerrain","NiNode",NULL);
 tolua_beginmodule(tolua_S,"NiTerrain");
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiTexture","NiTexture","",NULL);
 tolua_beginmodule(tolua_S,"NiTexture");
  tolua_function(tolua_S,"SetMipmapByDefault",tolua_gamebryo_NiTexture_SetMipmapByDefault00);
 tolua_endmodule(tolua_S);
 tolua_cclass(tolua_S,"NiSourceTexture","NiSourceTexture","",NULL);
 tolua_beginmodule(tolua_S,"NiSourceTexture");
  tolua_function(tolua_S,"SetUseMipmapping",tolua_gamebryo_NiSourceTexture_SetUseMipmapping00);
 tolua_endmodule(tolua_S);
 #ifdef __cplusplus
 tolua_cclass(tolua_S,"NiStream","NiStream","efd::MemObject",tolua_collect_NiStream);
 #else
 tolua_cclass(tolua_S,"NiStream","NiStream","efd::MemObject",NULL);
 #endif
 tolua_beginmodule(tolua_S,"NiStream");
  tolua_function(tolua_S,"new",tolua_gamebryo_NiStream_new00);
  tolua_function(tolua_S,"new_local",tolua_gamebryo_NiStream_new00_local);
  tolua_function(tolua_S,".call",tolua_gamebryo_NiStream_new00_local);
  tolua_function(tolua_S,"delete",tolua_gamebryo_NiStream_delete00);
  tolua_function(tolua_S,"GetObjectCount",tolua_gamebryo_NiStream_GetObjectCount00);
  tolua_function(tolua_S,"GetObjectAt",tolua_gamebryo_NiStream_GetObjectAt00);
  tolua_function(tolua_S,"Load",tolua_gamebryo_NiStream_Load00);
 tolua_endmodule(tolua_S);
 tolua_function(tolua_S,"EE_DELETE",tolua_gamebryo_EE_DELETE02);
 tolua_cclass(tolua_S,"NiMaterial","NiMaterial","",NULL);
 tolua_beginmodule(tolua_S,"NiMaterial");
  tolua_function(tolua_S,"SetDefaultWorkingDirectory",tolua_gamebryo_NiMaterial_SetDefaultWorkingDirectory00);
 tolua_endmodule(tolua_S);
 tolua_function(tolua_S,"InitEngine",tolua_gamebryo_InitEngine00);
 tolua_function(tolua_S,"ReleaseEngine",tolua_gamebryo_ReleaseEngine00);
 tolua_function(tolua_S,"SetMemoryLog",tolua_gamebryo_SetMemoryLog00);
 tolua_function(tolua_S,"NiDrawScene",tolua_gamebryo_NiDrawScene00);
 tolua_constant(tolua_S,"EE_DEGREES_TO_RADIANS",EE_DEGREES_TO_RADIANS);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 int luaopen_gamebryo (lua_State* tolua_S) {
 return tolua_gamebryo_open(tolua_S);
};
#endif

